/* * Copyright © 2020-2024 spj * Released under the MIT License. */
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('axios')) :
  typeof define === 'function' && define.amd ? define(['axios'], factory) :
  (global = global || self, global.upload = factory(global.axios));
}(this, function (axios) { 'use strict';

  axios = axios && axios.hasOwnProperty('default') ? axios['default'] : axios;

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(source, true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(source).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  var script = {
    name: 'Upload',
    components: {},
    props: {
      uploadUrl: {
        type: String,
        required: true,
        default: undefined
      },
      name: {
        type: String,
        default: '选择文件'
      },
      value: {
        type: [String, Array],
        default: ''
      },
      header: {
        type: Object,
        default: function _default() {}
      },
      multiple: {
        type: Boolean,
        default: false
      },
      data: {
        type: Object,
        default: function _default() {}
      },
      beforeUpload: {
        type: Function,
        default: undefined
      }
    },
    data: function data() {
      return {};
    },
    created: function created() {},
    mounted: function mounted() {},
    methods: {
      onSelectFileEvent: function onSelectFileEvent() {
        this.$refs.fileSelector.click();
      },
      onFileChangeEvent: function onFileChangeEvent(files) {
        var selectFiles = this.$refs.fileSelector.files;

        if (this.beforeUpload && typeof this.beforeUpload === 'function' && !this.beforeUpload(selectFiles)) {
          return;
        }

        this.uploadFileList(selectFiles);
      },
      uploadFileList: function uploadFileList(files) {
        var _this = this;

        var extData = _objectSpread2({}, this.data);

        var _loop = function _loop(i, len) {
          var formData = new FormData();
          formData.append('file', files[i]); // 通过append向form对象添加数据

          Object.keys(extData).forEach(function (key) {
            formData.append(key, extData[key]); // 添加form表单中其他数据
          });
          var fileInfo = {
            fileName: files[i].name,
            type: files[i].type,
            file: files[i]
          };
          var options = {
            url: _this.url,
            headers: _this.headers,
            timeout: 30000,
            // 请求超时时间
            onUploadProgress: function onUploadProgress(res) {
              var progress = Math.floor(res.loaded / res.total * 10) / 10;

              _this.$emit('onUploadProgress', _objectSpread2({}, fileInfo, {
                progress: progress
              }));
            }
          };
          axios.create(options).post(_this.uploadUrl, formData).then(function (res) {
            if (res.status === 200) {
              _this.$emit('change', _objectSpread2({
                response: res.data
              }, fileInfo));

              console.log('==上传成功==', res.data);
            } else {
              console.error('==上传失败==', res);

              _this.$emit('fail', _objectSpread2({}, fileInfo, {
                msgData: res
              }));
            }
          }).catch(function (reason) {
            _this.$emit('fail', _objectSpread2({}, fileInfo, {
              msgData: reason
            }));

            console.error('==上传失败==', reason);
          });
        };

        for (var i = 0, len = files.length; i < len; i++) {
          _loop(i);
        }
      }
    }
  };

  function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier
  /* server only */
  , shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
    if (typeof shadowMode !== 'boolean') {
      createInjectorSSR = createInjector;
      createInjector = shadowMode;
      shadowMode = false;
    } // Vue.extend constructor export interop.


    var options = typeof script === 'function' ? script.options : script; // render functions

    if (template && template.render) {
      options.render = template.render;
      options.staticRenderFns = template.staticRenderFns;
      options._compiled = true; // functional template

      if (isFunctionalTemplate) {
        options.functional = true;
      }
    } // scopedId


    if (scopeId) {
      options._scopeId = scopeId;
    }

    var hook;

    if (moduleIdentifier) {
      // server build
      hook = function hook(context) {
        // 2.3 injection
        context = context || // cached call
        this.$vnode && this.$vnode.ssrContext || // stateful
        this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
        // 2.2 with runInNewContext: true

        if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
          context = __VUE_SSR_CONTEXT__;
        } // inject component styles


        if (style) {
          style.call(this, createInjectorSSR(context));
        } // register component module identifier for async chunk inference


        if (context && context._registeredComponents) {
          context._registeredComponents.add(moduleIdentifier);
        }
      }; // used by ssr in case component is cached and beforeCreate
      // never gets called


      options._ssrRegister = hook;
    } else if (style) {
      hook = shadowMode ? function () {
        style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
      } : function (context) {
        style.call(this, createInjector(context));
      };
    }

    if (hook) {
      if (options.functional) {
        // register for functional component in vue file
        var originalRender = options.render;

        options.render = function renderWithStyleInjection(h, context) {
          hook.call(context);
          return originalRender(h, context);
        };
      } else {
        // inject component registration as beforeCreate hook
        var existing = options.beforeCreate;
        options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
      }
    }

    return script;
  }

  var normalizeComponent_1 = normalizeComponent;

  /* script */
  var __vue_script__ = script;
  /* template */
  var __vue_render__ = function() {
    var _vm = this;
    var _h = _vm.$createElement;
    var _c = _vm._self._c || _h;
    return _c(
      "div",
      {
        staticClass: "sv-upload-button",
        on: {
          click: function($event) {
            $event.stopPropagation();
            return _vm.onSelectFileEvent($event)
          }
        }
      },
      [
        _c("input", {
          ref: "fileSelector",
          staticClass: "sv-input-bt",
          staticStyle: { display: "none" },
          attrs: { multiple: _vm.multiple, name: _vm.name, type: "file" },
          on: { change: _vm.onFileChangeEvent }
        }),
        _vm._v(" "),
        _vm._t("default")
      ],
      2
    )
  };
  var __vue_staticRenderFns__ = [];
  __vue_render__._withStripped = true;

    /* style */
    var __vue_inject_styles__ = undefined;
    /* scoped */
    var __vue_scope_id__ = undefined;
    /* module identifier */
    var __vue_module_identifier__ = undefined;
    /* functional template */
    var __vue_is_functional_template__ = false;
    /* style inject */
    
    /* style inject SSR */
    

    
    var Upload = normalizeComponent_1(
      { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
      __vue_inject_styles__,
      __vue_script__,
      __vue_scope_id__,
      __vue_is_functional_template__,
      __vue_module_identifier__,
      undefined,
      undefined
    );

  Upload.install = function (vue) {
    vue.component(Upload.name, Upload);
  };

  return Upload;

}));
